home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / mac_file / vendor_d / neuralwa / nw2v50 / uio_cmds.c < prev    next >
Text File  |  1993-08-23  |  23KB  |  752 lines
  1. /* uio_cmds.c */
  2. /************************************************************************
  3.  * Copyright(C) 1987-1992 NeuralWare Inc                                *
  4.  * Penn Center West, IV-227, Pittsburgh, PA 15276                       *
  5.  * Telephone: (412) 787-8222    FAX: (412) 787-8220                     *
  6.  *                                                                      *
  7.  * All rights reserved.  No part of this program may be reproduced,     *
  8.  * stored in a retrieval system, or transmitted, in any form or by any  *
  9.  * means, electronic, mechanical, photocopying, recording or otherwise  *
  10.  * without the prior written permission of the copyright owner,         *
  11.  * NeuralWare, Inc.                                                     *
  12.  *                                                                      *
  13.  *                          PROPRIETARY NOTICE                          *
  14.  *                                                                      *
  15.  * This document is the property of NeuralWare, Inc. and contains       *
  16.  * trade-secrets and other proprietary information.  The information    *
  17.  * herein is reserved as proprietary to NeuralWare, and is not to be    *
  18.  * published, reproduced, copied, disclosed, used, or reverse           *
  19.  * engineered without the express written consent of a duly authorized  *
  20.  * representative of NeuralWare.                                        *
  21.  ************************************************************************
  22.  */
  23.  
  24. /*******************************************************************/
  25. /*                                                                 */
  26. /*    uio_cmds.c - User IO program template showing format of all  */
  27. /*                 all commands from NeuralWorks. A User program   */
  28. /*                 must provide all these functions                */
  29. /*                                                                 */
  30. /*    Documentation: TR Young         December 27, 1990            */
  31. /*    Author: John C. Fairman           August 31, 1990            */
  32. /*    Copyright 1990 by NeuralWare Inc.                            */
  33. /*                                                                 */
  34. /*    $Author   :  $                                               */
  35. /*    $Date     :  $                                               */
  36. /*    $Source   :  $                                               */
  37. /*    $Revision :  $                                               */
  38. /*    $Log      :  $                                               */
  39. /*                                                                 */
  40. /*******************************************************************/
  41. /*
  42.  *
  43.  * Functions necessary for handling the User I/O package itself:
  44.  *
  45.  *  UIO_Init()
  46.  *  UIO_Term()
  47.  *  UIO_Attention()
  48.  *
  49.  *
  50.  * Functions necessary for handling a learning session:
  51.  *
  52.  *  UIO_Learn_Start()
  53.  *  UIO_Learn_Input()
  54.  *  UIO_Learn_Output()
  55.  *  UIO_Learn_Result()
  56.  *  UIO_Learn_End()
  57.  *
  58.  *
  59.  * Functions necessary for handling a recall or testing session:
  60.  *
  61.  *  UIO_Recall_Start()
  62.  *  UIO_Read()
  63.  *  UIO_Write()
  64.  *  UIO_Write_Step()
  65.  *  UIO_Recall_Test()
  66.  *  UIO_Recall_End()
  67.  *
  68.  *
  69.  * Other miscellaneous functions:
  70.  *
  71.  *  UIO_Instrument()
  72.  *  UIO_ObjFunc()
  73.  *  UIO_Rewind()
  74.  *  UIO_Explain()
  75.  *
  76.  *
  77.  * Note: All these functions must be defined to avoid link errors.
  78.  *       Fill in the ones you need for your UserIO program.
  79.  */
  80.  
  81. /******************************************************************
  82.  * NOTE: Do not include <stdio.h>.  This is dealt with in userutl.h
  83.  * and related files. Some platforms, such as the Macintosh, redefine
  84.  * the stdio functions.
  85.  *
  86.  */
  87.  
  88. #define UIO_SERVER             1
  89. #define SERVER_EMULATOR_FILE   1
  90. #define SKIP_COMPAT_DATA       1
  91. #include "userutl.h"
  92. #include "uio_strc.h"
  93. #include "uio_tran.h"
  94. #include "uio_reqs.pro"
  95. #include "uio_cmds.pro"
  96.  
  97. #ifdef MAC
  98. #include "macuio.redef"
  99. #endif
  100.  
  101. /*******************************************************************/
  102. /*                                                                 */
  103. /* Functions necessary for handling the User I/O package itself.   */
  104. /*                                                                 */
  105. /*******************************************************************/
  106.  
  107. /* function:  UIO_Init.c
  108.  *    Executed once by NWorks at the begining of User IO execution.
  109.  *    Used for function initialization, memory allocation, file openning.
  110.  *
  111.  * arguments: file     = name of the User IO program being executed
  112.  *
  113.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  114.  *          UIO_UPDATE =  1,  continue execution, do update screen
  115.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  116.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  117.  */
  118.  
  119. NINT UIO_Init(file)
  120. TEXT *file;
  121. {
  122.    NINT ret_val = UIO_OK;
  123.    
  124.    
  125.    /* USER TO PLACE CODE HERE */
  126.    
  127.    return(ret_val);
  128. }
  129.  
  130.  
  131. /* */
  132. /* function:  UIO_Term()
  133.  *    Executed once by NWorks before loading another User IO program
  134.  *    or whenever deleting the network using either menu selections
  135.  *    or dialog boxes:
  136.  *
  137.  *      IO...||Parameters||USRIO filename selection
  138.  *      File...||Open...||NWorks filename selection
  139.  *      File...||New
  140.  *      File...||Close
  141.  *      File...||Revert to Saved
  142.  *      File...||Quit
  143.  *
  144.  *    Used to release all allocated memory, close any open files, etc.
  145.  *    to clean up after the User IO program execution
  146.  *
  147.  * arguments: process    = integer number assigned to User IO task
  148.  *
  149.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  150.  *          UIO_UPDATE =  1,  continue execution, do update screen
  151.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  152.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  153.  */
  154.  
  155. NINT UIO_Term(process)
  156. NINT process;
  157. {
  158.    NINT ret_val = UIO_OK;
  159.    
  160.    
  161.    /* USER TO PLACE CODE HERE */
  162.    
  163.    return(ret_val);
  164. }
  165.  
  166. /* function:  UIO_Attention()
  167.  *    Executed once by NWorks at menu selection:
  168.  *
  169.  *        I/O...||Attention I/O
  170.  *
  171.  *    Used for function initialization,
  172.  *    keyboard input of learn/recall parameters, etc.
  173.  *
  174.  *    Also used for the main body of a User Control program
  175.  *
  176.  * arguments: none
  177.  *
  178.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  179.  *          UIO_UPDATE =  1,  continue execution, do update screen
  180.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  181.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  182.  */
  183.  
  184. NINT UIO_Attention()
  185. {
  186.    NINT ret_val = UIO_OK;
  187.    
  188.    
  189.    /* USER TO PLACE CODE HERE */
  190.    
  191.    return(ret_val);
  192. }
  193.  
  194.  
  195. /*******************************************************************/
  196. /*                                                                 */
  197. /*  Functions necessary for handling a learning session.           */
  198. /*                                                                 */
  199. /*******************************************************************/
  200.  
  201. /* function:  UIO_Learn_Start()
  202.  *    Executed by NWorks at the begining of learn exectution
  203.  *    from menu selections:
  204.  *          Run...||Learn...||For nn
  205.  *          Run...||Learn...||One Pass/All
  206.  *          Run...||Learn...||One
  207.  *          Run...||Learn...||Now
  208.  *          Run...||Learn...||Until
  209.  *
  210.  *    Used for function initialization,
  211.  *    keyboard input of learn parameters, etc.
  212.  *
  213.  * arguments: none
  214.  *
  215.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  216.  *          UIO_UPDATE =  1,  continue execution, do update screen
  217.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  218.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  219.  */
  220.  
  221. NINT UIO_Learn_Start()
  222. {
  223.    NINT ret_val = UIO_OK;
  224.    
  225.    
  226.    /* USER TO PLACE CODE HERE */
  227.    
  228.    return(ret_val);
  229. }
  230.  
  231.  
  232. /* */
  233. /* function:  UIO_Learn_Input.c
  234.  *    Executed by NWorks during learn execution whenever a 
  235.  *    control strategy instruction:
  236.  *
  237.  *    io  lrnin
  238.  *
  239.  *    is encountered.
  240.  *    Used for reading predictor variable (i.e. Input or X in Y=f(X))
  241.  *    information into network.
  242.  *
  243.  * arguments: LayN     = index assigned to the layer that
  244.  *           will receive the input data;
  245.  *           index is assigned according to relative
  246.  *           (to other layers) screen position
  247.  *
  248.  *    nPEs     = dimension of the input data array
  249.  *
  250.  *    Datap    = pointer to array to be filled with input data
  251.  *
  252.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  253.  *          UIO_UPDATE =  1,  continue execution, do update screen
  254.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  255.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  256.  */
  257.  
  258. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  259. NINT  LayN;
  260. NINT  nPEs;
  261. SREAL *Datap;
  262. {
  263.    NINT ret_val = UIO_OK;
  264.    
  265.    
  266.    /* USER TO PLACE CODE HERE */
  267.    
  268.    return(ret_val);
  269. }
  270.  
  271.  
  272. /* function:  UIO_Learn_Output()
  273.  *    Executed by NWorks during learn execution whenever a 
  274.  *    control strategy instruction:
  275.  *
  276.  *    io  lrnout
  277.  *
  278.  *    is encountered.
  279.  *    Used for reading observed response variable
  280.  *    (i.e. desired Output or Y in Y=f(X))
  281.  *    information into network.
  282.  *
  283.  * arguments: LayN     = index assigned to the layer that
  284.  *           will receive the input data;
  285.  *           index is assigned according to relative
  286.  *           (to other layers) screen position
  287.  *
  288.  *    nPEs     = dimension of the input data array
  289.  *
  290.  *    Datap    = pointer to array to be filled with input data
  291.  *
  292.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  293.  *          UIO_UPDATE =  1,  continue execution, do update screen
  294.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  295.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  296.  */
  297.  
  298. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  299. NINT  LayN;
  300. NINT  nPEs;
  301. SREAL *Datap;
  302. {
  303.    NINT ret_val = UIO_OK;
  304.    
  305.    
  306.    /* USER TO PLACE CODE HERE */
  307.    
  308.    return(ret_val);
  309. }
  310.  
  311.  
  312. /* */
  313.  
  314. /* function:  UIO_Learn_Result()
  315.  *    Executed by NWorks during learn execution given a
  316.  *    control strategy instruction:
  317.  *
  318.  *    io  lrnrslt
  319.  *
  320.  *    is encountered.
  321.  *    Nworks returns predicted response (i.e. Result or
  322.  *    Y-hat in Y=f(X) where f is the estimated network)
  323.  *    information caluclated by network.
  324.  *
  325.  * arguments: LayN     = index assigned to the layer that
  326.  *           returns the predicted response output;
  327.  *           index is assigned according to relative
  328.  *           (to other layers) screen position
  329.  *
  330.  *    nPEs     = dimension of the output data array
  331.  *
  332.  *    Datap    = pointer to array that contains output data
  333.  *
  334.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  335.  *          UIO_UPDATE =  1,  continue execution, do update screen
  336.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  337.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  338.  */
  339.  
  340. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  341. NINT  LayN;
  342. NINT  nPEs;
  343. SREAL *Datap;
  344. {
  345.    NINT ret_val = UIO_OK;
  346.    
  347.    
  348.    /* USER TO PLACE CODE HERE */
  349.    
  350.    return(ret_val);
  351. }
  352.  
  353.  
  354. /* function:  UIO_Learn_End()
  355.  *    Called by NWorks at the end of learn exectution.
  356.  *    Used for summary information of learn procedure.
  357.  *
  358.  * arguments: none
  359.  *
  360.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  361.  *          UIO_UPDATE =  1,  continue execution, do update screen
  362.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  363.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  364.  */
  365.  
  366. NINT UIO_Learn_End()
  367. {
  368.    NINT ret_val = UIO_OK;
  369.    
  370.    
  371.    /* USER TO PLACE CODE HERE */
  372.    
  373.    return(ret_val);
  374. }
  375.  
  376.  
  377. /* */
  378. /*******************************************************************/
  379. /*                                                                 */
  380. /*  Functions necessary for handling a recall or testing session.  */
  381. /*                                                                 */
  382. /*******************************************************************/
  383.  
  384. /* function:  UIO_Recall_Start()
  385.  *    Executed once by NWorks at the beginning of recall execution
  386.  *    from menu selections:
  387.  *
  388.  *      Run...||Test...||For nn
  389.  *      Run...||Test...||One Pass/All
  390.  *      Run...||Test...||One
  391.  *      Run...||Recall...||For nn
  392.  *      Run...||Recall...||One Pass/All
  393.  *      Run...||Recall...||One
  394.  *      Run...||Recall...||Now
  395.  *
  396.  *    Used for function initialization,
  397.  *    keyboard input of recall parameters, etc.
  398.  *
  399.  * arguments: none
  400.  *
  401.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  402.  *          UIO_UPDATE =  1,  continue execution, do update screen
  403.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  404.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  405.  */
  406.  
  407.  
  408. NINT UIO_Recall_Start()
  409. {
  410.    NINT ret_val = UIO_OK;
  411.    
  412.    
  413.    /* USER TO PLACE CODE HERE */
  414.    
  415.    return(ret_val);
  416. }
  417.  
  418.  
  419. /* function:  UIO_Read()
  420.  *    Executed by NWorks during learn execution whenever a 
  421.  *    control strategy instruction:
  422.  *            read
  423.  *    is encountered.
  424.  *    Used for supplying predictor variable
  425.  *    (i.e. Input or X in Y=f(X))
  426.  *    information to NWorks network.
  427.  *
  428.  * arguments: LayN     = index assigned to the layer that
  429.  *           will receive the input data;
  430.  *           index is assigned according to relative
  431.  *           (to other layers) screen position
  432.  *
  433.  *    nPEs     = dimension of the input data array
  434.  *
  435.  *    Datap    = pointer to array to be filled with input data
  436.  *
  437.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  438.  *          UIO_UPDATE =  1,  continue execution, do update screen
  439.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  440.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  441.  */
  442.  
  443. NINT UIO_Read(LayN, nPEs, Datap)
  444. NINT  LayN;
  445. NINT  nPEs;
  446. SREAL *Datap;
  447. {
  448.    NINT ret_val = UIO_OK;
  449.    
  450.    
  451.    /* USER TO PLACE CODE HERE */
  452.    
  453.    return(ret_val);
  454. }
  455.  
  456.  
  457. /* function:  UIO_Write()
  458.  *    Executed by NWorks during learn execution whenever a 
  459.  *    control strategy instruction:
  460.  *            rcltst
  461.  *    is encountered.
  462.  *    Nworks gives User IO predicted response
  463.  *    (i.e. Actual Output or Y-hat in Y=f(X) where
  464.  *    f is the NWorks estimated network)
  465.  *    information from the NWorks network.
  466.  *
  467.  * arguments: LayN     = index assigned to the layer that
  468.  *           returns the predicted response output;
  469.  *           index is assigned according to relative
  470.  *           (to other layers) screen position
  471.  *
  472.  *    nPEs     = dimension of the output data array
  473.  *
  474.  *    Datap    = pointer to array that contains output data
  475.  *
  476.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  477.  *          UIO_UPDATE =  1,  continue execution, do update screen
  478.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  479.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  480.  */
  481.  
  482. NINT UIO_Write(LayN, nPEs, Datap)
  483. NINT  LayN;
  484. NINT  nPEs;
  485. SREAL *Datap;
  486. {
  487.    NINT ret_val = UIO_OK;
  488.    
  489.    
  490.    /* USER TO PLACE CODE HERE */
  491. #ifdef _MSC_VER
  492.    ret_val = 567;
  493.    /* printf("set return value to %d\n",ret_val); */
  494. #endif
  495.    
  496.    return(ret_val);
  497. }
  498.  
  499.  
  500. /* function:  UIO_Write_Step()
  501.  *    Executed by NWorks during learn execution whenever a
  502.  *    control strategy instruction:
  503.  *            wrstep
  504.  *    is encountered.
  505.  *    Nworks gives User IO predicted partial response
  506.  *    (i.e. Actual Output or Y-hat in Y=f_j(X) where
  507.  *    f_j is the j is the LayN-th layer of the NWorks
  508.  *    estimated network) at the specified layer using
  509.  *    information supplied to, and caluclated by, the network.
  510.  *
  511.  * arguments: LayN     = index assigned to the layer that
  512.  *           returns the predicted partial response output;
  513.  *           index is assigned according to relative
  514.  *           (to other layers) screen position
  515.  *
  516.  *    nPEs     = dimension of the output data array
  517.  *
  518.  *    Datap    = pointer to array that contains output data
  519.  *
  520.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  521.  *          UIO_UPDATE =  1,  continue execution, do update screen
  522.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  523.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  524.  */
  525.  
  526. NINT UIO_Write_Step(LayN, nPEs, Datap)
  527. NINT  LayN;
  528. NINT  nPEs;
  529. SREAL *Datap;
  530. {
  531.    NINT ret_val = UIO_OK;
  532.    
  533.    
  534.    /* USER TO PLACE CODE HERE */
  535.    
  536.    return(ret_val);
  537. }
  538.  
  539.  
  540. /* */
  541. /* function:  UIO_Recall_Test()
  542.  *    Executed by NWorks during learn execution whenever a 
  543.  *    control strategy instruction:
  544.  *            rcltst
  545.  *    is encountered.
  546.  *    Used for supplying observed response variable
  547.  *    (i.e. Test data or Desired Output or Y in Y=f(X))
  548.  *    information to NWorks network.
  549.  *
  550.  * arguments: LayN     = index assigned to the layer that
  551.  *           will receive the input data;
  552.  *           index is assigned according to relative
  553.  *           (to other layers) screen position
  554.  *
  555.  *    nPEs     = dimension of the input data array
  556.  *
  557.  *    Datap    = pointer to array to be filled with input data
  558.  *
  559.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  560.  *          UIO_UPDATE =  1,  continue execution, do update screen
  561.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  562.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  563.  */
  564.  
  565. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  566. NINT  LayN;
  567. NINT  nPEs;
  568. SREAL *Datap;
  569. {
  570.    NINT ret_val = UIO_OK;
  571.    
  572.    
  573.    /* USER TO PLACE CODE HERE */
  574.    
  575.    return(ret_val);
  576. }
  577.  
  578. /* function:  UIO_Recall_End()
  579.  *    Executed once by NWorks at the end of recall execution
  580.  *    from menu selection:
  581.  *
  582.  *      Run...||Test...||For nn
  583.  *      Run...||Test...||One Pass/All
  584.  *      Run...||Test...||One
  585.  *      Run...||Recall...||For nn
  586.  *      Run...||Recall...||One Pass/All
  587.  *      Run...||Recall...||One
  588.  *      Run...||Recall...||Now
  589.  *
  590.  *    Used for function initialization,
  591.  *    keyboard input of learn parameters, etc.
  592.  *
  593.  * arguments: none
  594.  *
  595.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  596.  *          UIO_UPDATE =  1,  continue execution, do update screen
  597.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  598.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  599.  */
  600.  
  601. NINT UIO_Recall_End()
  602. {
  603.    NINT ret_val = UIO_OK;
  604.    
  605.    
  606.    /* USER TO PLACE CODE HERE */
  607.    
  608.    return(ret_val);
  609. }
  610.  
  611.  
  612. /* */
  613. /*******************************************************************/
  614. /*                                                                 */
  615. /*  Other miscellaneous functions.                                  */
  616. /*                                                                 */
  617. /*******************************************************************/
  618.  
  619. /* function:  UIO_Instrument()
  620.  *    Executed by NWorks whenever an instrument generates
  621.  *    logging output that is sent to UIO
  622.  *    (User IO selected for logging in instrument edit dialog box)
  623.  *
  624.  * arguments: Instrument_id = integer assigned to instrument
  625.  *        that sent logging output
  626.  *    nDataElems    = integer dimension of array
  627.  *        that holds logging output
  628.  *    DataElemp     = floating pointer to array
  629.  *        that holds logging output
  630.  *
  631.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  632.  *          UIO_UPDATE =  1,  continue execution, do update screen
  633.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  634.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  635.  */
  636.  
  637. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  638. NINT  Instrument_id;
  639. NINT  nDataElems;
  640. SREAL *DataElemp;
  641. {
  642.    NINT ret_val = UIO_OK;
  643.    
  644.    
  645.    /* USER TO PLACE CODE HERE */
  646.    
  647.    return(ret_val);
  648. }
  649.  
  650.  
  651. /* function:  UIO_ObjFunc()
  652.  *    Executed by NWorks when the NeuralWorks Objective function
  653.  *    is specified as UserIO, called during a NeuralWorks SaveBest
  654.  *    at start of testing and at the end of testing.
  655.  *
  656.  * arguments:
  657.  *    eoeflag       = 0 (start of testing), =1 (end of testing)
  658.  *    DataElemp     = place to put objective function output
  659.  *                    (eoeflag = 1 only)
  660.  *                    DataElemp[0] = value;
  661.  *
  662.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  663.  *          UIO_UPDATE =  1,  continue execution, do update screen
  664.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  665.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  666.  */
  667.  
  668. NINT UIO_ObjFunc(eoeflag, DataElemp)
  669. NINT  eoeflag;
  670. SREAL *DataElemp;
  671. {
  672.    NINT ret_val = UIO_OK;
  673.    
  674.    
  675.    /* USER TO PLACE CODE HERE */
  676.    
  677.    return(ret_val);
  678. }
  679.  
  680.  
  681. /* function:  UIO_Rewind()
  682.  *    Executed once by NWorks from menu selections:
  683.  *
  684.  *      I/O...||Rewind Input...||All
  685.  *      I/O...||Rewind Input...||Learn
  686.  *      I/O...||Rewind Input...||Rcl/Test
  687.  *      I/O...||Rewind Input...||Close File(s)
  688.  *
  689.  *    Used for input file rewinding, closing files
  690.  *
  691.  * arguments: none
  692.  *
  693.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  694.  *          UIO_UPDATE =  1,  continue execution, do update screen
  695.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  696.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  697.  */
  698.  
  699. NINT UIO_Rewind()
  700. {
  701.    NINT ret_val = UIO_OK;
  702.    
  703.    
  704.    /* USER TO PLACE CODE HERE */
  705.    
  706.    return(ret_val);
  707. }
  708.  
  709.  
  710. /* */
  711. /* function:  UIO_Explain()
  712.  *    Executed by NWorks once for each PE in the Output Layer
  713.  *    during menu selections:
  714.  *
  715.  *      Run...||Explain...||For nn
  716.  *      Run...||Explain...||One Pass/All
  717.  *      Run...||Explain...||One
  718.  *      Run...||Explain...||Now
  719.  *
  720.  *    Allows input of information for the NWorks Explain feature.
  721.  *
  722.  * arguments: LayN     = index assigned to the layer that
  723.  *           will receive the predicted response output;
  724.  *           index is assigned according to relative
  725.  *           (to other layers) screen position
  726.  *
  727.  *    nPEs     = dimension of the input data array, the number
  728.  *           of PE's in the input layer
  729.  *
  730.  *    Datap    = pointer to array that contains input data
  731.  *
  732.  * return:  UIO_OK     =  0,  continue execution, do not update screen
  733.  *          UIO_UPDATE =  1,  continue execution, do update screen
  734.  *          UIO_EXIT   =  2,  terminate execution, no error, update screen
  735.  *          UIO_ERROR  = -1,  terminate execution, do update screen
  736.  */
  737.  
  738. NINT UIO_Explain(LayN, nPEs, Datap)
  739. NINT  LayN;
  740. NINT  nPEs;
  741. SREAL *Datap;
  742. {
  743.    NINT ret_val = UIO_OK;
  744.    
  745.    
  746.    /* USER TO PLACE CODE HERE */
  747.    
  748.    return(ret_val);
  749. }
  750.  
  751.  
  752.